package com.sweet.util;

import com.sweet.lang.StringUtil;

/**
 * 数据转换工具
 *
 * @author limi
 * @version 2015-10-15
 */
public final class ConvertUtil {
    private ConvertUtil() {
    }

    /**
     * 转为字符串
     *
     * @param object 转换对象
     * @return 转换失败则为null
     */
    public static String toString(final Object object) {
        return toString(object, null);
    }

    /**
     * 转为字符串
     *
     * @param object       转换对象
     * @param defaultValue 默认值
     * @return 转换失败则使用默认值
     */
    public static String toString(final Object object, final String defaultValue) {
        return object == null ? defaultValue : object.toString();
    }

    /**
     * 转为double
     *
     * @param text
     * @return 转换失败则为0
     */
    public static double toDouble(final String text) {
        return toDouble(text, 0);
    }

    /**
     * 转为double
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static double toDouble(final String text, double defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Double.parseDouble(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 转为float
     *
     * @param text
     * @return 转换失败则为0
     */
    public static float toFloat(final String text) {
        return toFloat(text, 0);
    }

    /**
     * 转为float
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static float toFloat(final String text, float defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Float.parseFloat(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 将字符串转为long,转换失败则为null
     *
     * @param value
     * @return
     */
    public static Long parseLong(final String value) {
        try {
            return StringUtil.isBlank(value) ? null : Long.parseLong(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 转为long
     *
     * @param text
     * @return 转换失败则为0
     */
    public static long toLong(final String text) {
        return toLong(text, 0);
    }

    /**
     * 转为long
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static long toLong(final String text, long defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Long.parseLong(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 将字符串转为int,转换失败则为null
     *
     * @param value
     * @return
     */
    public static Integer parseInt(final String value) {
        try {
            return StringUtil.isBlank(value) ? null : Integer.parseInt(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 转为int
     *
     * @param text
     * @return 转换失败则为0
     */
    public static int toInt(final String text) {
        return toInt(text, 0);
    }

    /**
     * 转为int
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static int toInt(final String text, int defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Integer.parseInt(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 将字符串转为short,转换失败则为null
     *
     * @param value
     * @return
     */
    public static Short parseShort(final String value) {
        try {
            return StringUtil.isBlank(value) ? null : Short.parseShort(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 转为short
     *
     * @param text
     * @return 转换失败则为0
     */
    public static short toShort(final String text) {
        return toShort(text, (short) 0);
    }

    /**
     * 转为short
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static short toShort(final String text, short defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Short.parseShort(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 将字符串转为byte,转换失败则为null
     *
     * @param value
     * @return
     */
    public static Byte parseByte(final String value) {
        try {
            return StringUtil.isBlank(value) ? null : Byte.parseByte(value);
        } catch (NumberFormatException e) {
            return null;
        }
    }

    /**
     * 转为byte
     *
     * @param text
     * @return 转换失败则为0
     */
    public static byte toByte(final String text) {
        return toByte(text, (byte) 0);
    }

    /**
     * 转为byte
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static byte toByte(final String text, byte defaultValue) {
        try {
            return StringUtil.isBlank(text) ? defaultValue : Byte.parseByte(text);
        } catch (NumberFormatException e) {
            return defaultValue;
        }
    }

    /**
     * 将字符串转为boolean<br/>
     * 转换失败则为null
     *
     * @param value
     * @return
     */
    public static Boolean parseBoolean(final String value) {
        return StringUtil.isBlank(value) ? null : Boolean.parseBoolean(value);
    }

    /**
     * 转为boolean
     *
     * @param text
     * @return 转换失败则为false
     */
    public static boolean toBoolean(final String text) {
        return toBoolean(text, false);
    }

    /**
     * 将字符串转为boolean
     *
     * @param text
     * @param defaultValue
     * @return 转换失败则使用默认值
     */
    public static boolean toBoolean(final String text, boolean defaultValue) {
        return StringUtil.isBlank(text) ? defaultValue : Boolean.parseBoolean(text);
    }
}
